/**
 * 事件管理器
 * 负责管理页面间的事件通信和协调
 */
class EventManager {
    constructor() {
        this.events = new Map();
        this.globalHandlers = new Map();
    }

    /**
     * 注册事件监听器
     * @param {string} eventName - 事件名称
     * @param {Function} handler - 事件处理器
     * @param {string} pageId - 页面ID（可选）
     */
    on(eventName, handler, pageId = null) {
        const key = pageId ? `${pageId}:${eventName}` : eventName;
        
        if (!this.events.has(key)) {
            this.events.set(key, []);
        }
        
        this.events.get(key).push(handler);
        console.log(`[EventManager] 注册事件监听器: ${key}`);
    }

    /**
     * 移除事件监听器
     * @param {string} eventName - 事件名称
     * @param {Function} handler - 事件处理器
     * @param {string} pageId - 页面ID（可选）
     */
    off(eventName, handler, pageId = null) {
        const key = pageId ? `${pageId}:${eventName}` : eventName;
        
        if (this.events.has(key)) {
            const handlers = this.events.get(key);
            const index = handlers.indexOf(handler);
            if (index > -1) {
                handlers.splice(index, 1);
                console.log(`[EventManager] 移除事件监听器: ${key}`);
            }
        }
    }

    /**
     * 触发事件
     * @param {string} eventName - 事件名称
     * @param {*} data - 事件数据
     * @param {string} pageId - 页面ID（可选）
     */
    emit(eventName, data = null, pageId = null) {
        const keys = [];
        
        if (pageId) {
            // 特定页面的事件
            keys.push(`${pageId}:${eventName}`);
        }
        
        // 全局事件
        keys.push(eventName);
        
        keys.forEach(key => {
            if (this.events.has(key)) {
                const handlers = this.events.get(key);
                handlers.forEach(handler => {
                    try {
                        handler(data);
                    } catch (error) {
                        console.error(`[EventManager] 事件处理器执行失败: ${key}`, error);
                    }
                });
            }
        });
        
        console.log(`[EventManager] 触发事件: ${eventName}`, { pageId, data });
    }

    /**
     * 注册全局处理器
     * @param {string} name - 处理器名称
     * @param {Function} handler - 处理器函数
     */
    registerGlobalHandler(name, handler) {
        this.globalHandlers.set(name, handler);
        console.log(`[EventManager] 注册全局处理器: ${name}`);
    }

    /**
     * 调用全局处理器
     * @param {string} name - 处理器名称
     * @param {...*} args - 参数
     */
    callGlobalHandler(name, ...args) {
        const handler = this.globalHandlers.get(name);
        if (handler) {
            return handler(...args);
        } else {
            console.warn(`[EventManager] 未找到全局处理器: ${name}`);
            return null;
        }
    }

    /**
     * 清理所有事件监听器
     */
    clear() {
        this.events.clear();
        this.globalHandlers.clear();
        console.log('[EventManager] 所有事件监听器已清理');
    }

    /**
     * 清理特定页面的事件监听器
     * @param {string} pageId - 页面ID
     */
    clearPageEvents(pageId) {
        const keysToRemove = [];
        
        this.events.forEach((handlers, key) => {
            if (key.startsWith(`${pageId}:`)) {
                keysToRemove.push(key);
            }
        });
        
        keysToRemove.forEach(key => {
            this.events.delete(key);
        });
        
        console.log(`[EventManager] 清理页面 ${pageId} 的事件监听器`);
    }
}

/**
 * 页面管理器
 * 负责管理页面切换和状态
 */
class PageManager {
    constructor(pageLoader, eventManager) {
        this.pageLoader = pageLoader;
        this.eventManager = eventManager;
        this.currentPage = null;
        this.pageHistory = [];
    }

    /**
     * 切换到指定页面
     * @param {string} pageId - 页面ID
     */
    async switchToPage(pageId) {
        try {
            // 记录页面历史
            if (this.currentPage && this.currentPage !== pageId) {
                this.pageHistory.push(this.currentPage);
            }

            // 触发页面离开事件
            if (this.currentPage) {
                this.eventManager.emit('pageLeave', { from: this.currentPage, to: pageId });
            }

            // 更新导航菜单状态
            this.updateNavigationState(pageId);

            // 切换到新页面
            await this.pageLoader.showPage(pageId);
            this.currentPage = pageId;

            // 触发页面进入事件
            this.eventManager.emit('pageEnter', { from: this.pageHistory[this.pageHistory.length - 1], to: pageId });

            console.log(`[PageManager] 切换到页面: ${pageId}`);
        } catch (error) {
            console.error(`[PageManager] 切换页面失败: ${pageId}`, error);
        }
    }

    /**
     * 更新导航菜单状态
     * @param {string} pageId - 当前页面ID
     */
    updateNavigationState(pageId) {
        // 移除所有导航项的 active 类
        document.querySelectorAll('.nav-item').forEach(item => {
            item.classList.remove('active');
        });

        // 为当前页面的导航项添加 active 类
        const targetNavItem = document.querySelector(`[data-tab="${pageId}"]`);
        if (targetNavItem) {
            targetNavItem.classList.add('active');
            console.log(`[PageManager] 导航菜单已更新: ${pageId}`);
        } else {
            console.warn(`[PageManager] 未找到页面 ${pageId} 的导航项`);
        }
    }

    /**
     * 返回上一页
     */
    async goBack() {
        if (this.pageHistory.length > 0) {
            const previousPage = this.pageHistory.pop();
            await this.switchToPage(previousPage);
        }
    }

    /**
     * 获取当前页面
     */
    getCurrentPage() {
        return this.currentPage;
    }

    /**
     * 获取页面历史
     */
    getPageHistory() {
        return [...this.pageHistory];
    }

    /**
     * 清理页面历史
     */
    clearHistory() {
        this.pageHistory = [];
        console.log('[PageManager] 页面历史已清理');
    }
}

/**
 * 状态管理器
 * 负责管理应用状态和持久化
 */
class StateManager {
    constructor() {
        this.state = new Map();
        this.storageKey = 'claude-code-agent-state';
    }

    /**
     * 设置状态
     * @param {string} key - 状态键
     * @param {*} value - 状态值
     * @param {boolean} persist - 是否持久化
     */
    set(key, value, persist = false) {
        this.state.set(key, value);
        
        if (persist) {
            this.saveToStorage();
        }
        
        console.log(`[StateManager] 设置状态: ${key}`, value);
    }

    /**
     * 获取状态
     * @param {string} key - 状态键
     * @param {*} defaultValue - 默认值
     */
    get(key, defaultValue = null) {
        return this.state.get(key) || defaultValue;
    }

    /**
     * 删除状态
     * @param {string} key - 状态键
     */
    delete(key) {
        this.state.delete(key);
        this.saveToStorage();
        console.log(`[StateManager] 删除状态: ${key}`);
    }

    /**
     * 检查状态是否存在
     * @param {string} key - 状态键
     */
    has(key) {
        return this.state.has(key);
    }

    /**
     * 获取所有状态
     */
    getAll() {
        return Object.fromEntries(this.state);
    }

    /**
     * 清理所有状态
     */
    clear() {
        this.state.clear();
        this.saveToStorage();
        console.log('[StateManager] 所有状态已清理');
    }

    /**
     * 从存储加载状态
     */
    loadFromStorage() {
        try {
            const stored = localStorage.getItem(this.storageKey);
            if (stored) {
                const data = JSON.parse(stored);
                Object.entries(data).forEach(([key, value]) => {
                    this.state.set(key, value);
                });
                console.log('[StateManager] 从存储加载状态成功');
            }
        } catch (error) {
            console.error('[StateManager] 从存储加载状态失败:', error);
        }
    }

    /**
     * 保存状态到存储
     */
    saveToStorage() {
        try {
            const data = Object.fromEntries(this.state);
            localStorage.setItem(this.storageKey, JSON.stringify(data));
            console.log('[StateManager] 状态已保存到存储');
        } catch (error) {
            console.error('[StateManager] 保存状态到存储失败:', error);
        }
    }
}

/**
 * 工具函数集合
 */
class Utils {
    /**
     * 防抖函数
     * @param {Function} func - 要防抖的函数
     * @param {number} wait - 等待时间
     * @param {boolean} immediate - 是否立即执行
     */
    static debounce(func, wait, immediate = false) {
        let timeout;
        return function executedFunction(...args) {
            const later = () => {
                timeout = null;
                if (!immediate) func(...args);
            };
            const callNow = immediate && !timeout;
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
            if (callNow) func(...args);
        };
    }

    /**
     * 节流函数
     * @param {Function} func - 要节流的函数
     * @param {number} limit - 限制时间
     */
    static throttle(func, limit) {
        let inThrottle;
        return function executedFunction(...args) {
            if (!inThrottle) {
                func.apply(this, args);
                inThrottle = true;
                setTimeout(() => inThrottle = false, limit);
            }
        };
    }

    /**
     * 深拷贝对象
     * @param {*} obj - 要拷贝的对象
     */
    static deepClone(obj) {
        if (obj === null || typeof obj !== 'object') return obj;
        if (obj instanceof Date) return new Date(obj.getTime());
        if (obj instanceof Array) return obj.map(item => this.deepClone(item));
        if (typeof obj === 'object') {
            const clonedObj = {};
            Object.keys(obj).forEach(key => {
                clonedObj[key] = this.deepClone(obj[key]);
            });
            return clonedObj;
        }
    }

    /**
     * 生成唯一ID
     * @param {string} prefix - 前缀
     */
    static generateId(prefix = 'id') {
        return `${prefix}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    }

    /**
     * 格式化文件大小
     * @param {number} bytes - 字节数
     */
    static formatFileSize(bytes) {
        if (bytes === 0) return '0 Bytes';
        const k = 1024;
        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
        const i = Math.floor(Math.log(bytes) / Math.log(k));
        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
    }

    /**
     * 格式化时间
     * @param {Date|number} time - 时间
     * @param {string} format - 格式
     */
    static formatTime(time, format = 'YYYY-MM-DD HH:mm:ss') {
        const date = new Date(time);
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0');
        const day = String(date.getDate()).padStart(2, '0');
        const hours = String(date.getHours()).padStart(2, '0');
        const minutes = String(date.getMinutes()).padStart(2, '0');
        const seconds = String(date.getSeconds()).padStart(2, '0');

        return format
            .replace('YYYY', year)
            .replace('MM', month)
            .replace('DD', day)
            .replace('HH', hours)
            .replace('mm', minutes)
            .replace('ss', seconds);
    }

    /**
     * 验证邮箱格式
     * @param {string} email - 邮箱地址
     */
    static isValidEmail(email) {
        const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        return re.test(email);
    }

    /**
     * 验证URL格式
     * @param {string} url - URL地址
     */
    static isValidUrl(url) {
        try {
            new URL(url);
            return true;
        } catch {
            return false;
        }
    }
}

// 创建全局实例
window.eventManager = new EventManager();
window.stateManager = new StateManager();
window.utils = Utils;

// 导出到全局
window.EventManager = EventManager;
window.PageManager = PageManager;
window.StateManager = StateManager;
window.Utils = Utils;
